class Person{
    // 声明构造器中的属性的类型
    name:string;
    age:number
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }
    // 原型对象上的方法
    jump(a:string):string{
        return a+this.name;
    }
    // class类自身上的方法
    static run(x:number):number{
        return x
    }
}
let tom =new Person('tom',80);


// 如何调用原型对象上的方法  ----》使用实例对象可以通过隐式原型链访问到原型对象上的方法
console.log(tom.jump('aa'));  

// class类或者构造函数自身上的方法如何调用   对象自身上的方法  obj.xxx  obj['xxx']
console.log(Person.run(9));

// 使用接口规定类的数据类型
interface Anima{
    sound(str:string):string,
    height(num:number):number
}

// 接口定义类的数据类型时，使用 class 类名 implements  接口{} 去定义
// class Cat implements Anima{
//     sound(str: string): string {
//         return str
//     }
//     height(num: number): number {
//         return num
//     }
// }

// cat 根据Anima
interface Anima1{
    name(str:string):string
}
// 一个类可以使用多个接口进行规定
class Cat implements Anima1{
    sound(str:string):string{
        return str
    }
    height(num:number):number{
        return num
    }
    name(str: string): string {
        return str
    }
}
let Kitty =new Cat();
console.log(Kitty);
console.log(Kitty.height(12));
console.log(Kitty.sound('喵喵'));

// 接口可以继承
interface DogT{
    sound(str:string):string
}
interface DogM{
    weight(num:number):number
}

// 当前有两个接口,需求是创建一个Dog类，该类通过 两个接口进行类型规定，这个Dog类既有sound  run函数
// class Dog implements DogT,DogM{
//     sound(str: string): string {
//         return str
//     }
//     weight(num: number): number {
//         return num
//     }
// }
// let xiaobai = new Dog();
// console.log(xiaobai);
// console.log(xiaobai.sound('汪汪'));

// 写两个接口麻烦  可以合并成一个
// 接口继承接口
interface New extends DogM,DogT{
}
class Dog implements New{
    sound(str: string): string {
        return str
    }
    weight(num: number): number {
        return num
    }
}
let xiaobai = new Dog();
console.log(xiaobai);
console.log(xiaobai.weight(13));
console.log(xiaobai.sound('汪汪'));

// 在ts中写的变量 函数 对象。。。。都要规定数据类型

// class类的继承
class Student extends Person{
    sex:string;
    // 进行规定构造器当中参数的数据类型
    constructor(name:string,age:number,sex:string){
        super(name,age);
        this.sex=sex;
    }
    jump(a: string): string {
        return super.jump(a);
    }
}
let sizhe = new Student('sizhe',19,'男');
console.log(sizhe.jump('wa'));
// Student称为Person的子类，派生类
// Person 父类  基类  超类

/* 
修饰符：
public 默认值哪里都有访问
private 私有的 只有内部可以访问
protected 受保护的 只有内部和子类可以访问
*/
class Book{
    public name:string;
    private price:string;
    protected pages:number;
    constructor(name:string,price:string,pages:number){
        this.name=name;
        this.price=price;
        this.pages=pages;
    }
    sayBookName():string{
        // 在class内部
        console.log(this.price);
        console.log(this.pages);
        // 在class类内部访问
        return this.name
    }
}

let xiyouji= new Book('xiyouji','45',500);
console.log(xiyouji.name);
console.log(xiyouji);
console.log(xiyouji.sayBookName());
// 在class外部
// console.log(xiyouji.price);
// console.log(xiyouji.pages);

//protected内部和子类中可以访问 外部不能访问
class HouBook extends Book{
    constructor(name:string,price:string,pages:number){
        super(name,price,pages)
    }
    testPrice(){
        console.log(this.name);
        console.log(this.pages);
    }
}
let xiaohongshu = new HouBook('xiaohongshu','1亿',9999);
console.log(xiaohongshu.testPrice());



export {
    tom
}